eager evaluation造句

• Eager evaluation is the evaluation strategy employed in most programming languages.
• However the result may be different between lazy and eager evaluation.
• The opposite of lazy evaluation is eager evaluation, sometimes known as strict evaluation.
• The sequential subset of Erlang supports eager evaluation, single assignment, and dynamic typing.
• One advantage of eager evaluation is that it eliminates the need to track and schedule the evaluation of expressions.
• Outermost graph reduction is referred to as lazy evaluation and innermost graph reduction is referred to as eager evaluation.
• The distinction between reduction strategies relates to the distinction in functional programming languages between eager evaluation and lazy evaluation.
• While Pure uses eager evaluation by default, it also supports David Turner ) which computes the stream of all prime numbers:
• Imperative programming languages, where the order of execution is implicitly defined by the structure of the source code, almost always use eager evaluation.
• Unlambda's execution semantics are normally eager evaluation, but a lazy evaluation option exists, indicated by the use of the d operator.
• The operational semantics of ISWIM are defined using Landin's SECD machine and use call-by-value, that is eager evaluation.
• Under Church encoding, eager evaluation of operators maps to strict evaluation of functions; for this reason, strict evaluation is sometimes called " eager ".
• Strict programming languages are often associated with eager evaluation, and non-strict languages with lazy evaluation, but other evaluation strategies are possible in each case.
• Disadvantages of eager evaluation are that it forces the evaluation of expressions that may not be necessary at run time, and it may delay the evaluation of expressions that have a more immediate need.
• A followup paper showed that there is a lazily evaluated non-mutating algorithm with the same efficiency as the mutating algorithm ( so I guess one of the assumptions of the original paper was eager evaluation ).
• Plotkin also used a Church Rosser theorem to prove that the evaluation of functional programs ( for both lazy evaluation and eager evaluation ) is a function from programs to values ( a subset of the lambda terms ).
• When eager evaluation is desirable ( primarily when the sequence is finite, as otherwise evaluation will never terminate ), one can either convert to a list, or use a parallel construction that creates a list instead of a generator.
• The computation can start as soon as the future is created ( eager evaluation ) or only when the value is actually needed ( lazy evaluation ), and may be suspended part-way through, or executed in one run.
• As does the Haskell functional language, Alice also provides facilities to allow using a lazy evaluation strategy in programs, versus the traditional eager evaluation strategy of Standard ML . While Haskell uses the lazy model by default, Alice uses an eager evaluation model by default, needing an explicit programming statement for a computation to evaluate lazily.
• As does the Haskell functional language, Alice also provides facilities to allow using a lazy evaluation strategy in programs, versus the traditional eager evaluation strategy of Standard ML . While Haskell uses the lazy model by default, Alice uses an eager evaluation model by default, needing an explicit programming statement for a computation to evaluate lazily.